package common.util;
    import java.util.HashSet;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.HanyuPinyinVCharType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;
      
    /** 
     * @className:PinyinUtil.java 
     * @classDescription:拼音操作工具类 
     * @createTime:2010-10-21 
     */  
      
    public class PinyinUtil {  
      
        /** 
         * 将字符串转换成拼音数组 
         *  
         * @param src 
         * @return 
         */  
        public static String[] stringToPinyin(String src) {  
            return stringToPinyin(src, false, null);  
        }  
        /** 
         * 将字符串转换成拼音数组 
         *  
         * @param src 
         * @return 
         */  
        public static String[] stringToPinyin(String src,String separator) {  
            return stringToPinyin(src, true, separator);  
        }  
      
        /** 
         * 将字符串转换成拼音数组 
         *  
         * @param src 
         * @param isPolyphone 
         *            是否查出多音字的所有拼音 
         * @param separator 
         *            多音字拼音之间的分隔符 
         * @return 
         */  
        public static String[] stringToPinyin(String src, boolean isPolyphone,  
                String separator) {  
            // 判断字符串是否为空  
            if ("".equals(src) || null == src) {  
                return null;  
            }  
            char[] srcChar = src.toCharArray();  
            int srcCount = srcChar.length;  
            String[] srcStr = new String[srcCount];  
      
            for (int i = 0; i < srcCount; i++) {  
                srcStr[i] = charToPinyin(srcChar[i], isPolyphone, separator);  
            }  
            return srcStr;  
        }  
      
        /** 
         * 将单个字符转换成拼音 
         *  
         * @param src 
         * @return 
         */  
        public static String charToPinyin(char src, boolean isPolyphone,  
                String separator) {  
            // 创建汉语拼音处理类  
            HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();  
            // 输出设置，大小写，音标方式  
            defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);  
            defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE); 
            defaultFormat.setVCharType(HanyuPinyinVCharType.WITH_V);
      
            StringBuffer tempPinyin = new StringBuffer();  
              
      
            // 如果是中文  
            if (src > 128) {  
                try {  
                    // 转换得出结果  
                    String[] strs = PinyinHelper.toHanyuPinyinStringArray(src,  
                            defaultFormat);  
                      
                              
                    // 是否查出多音字，默认是查出多音字的第一个字符  
                    if (isPolyphone && null != separator) {  
                        for (int i = 0; i < strs.length; i++) {  
                            tempPinyin.append(strs[i]);  
                            if (strs.length != (i + 1)) {  
                                // 多音字之间用特殊符号间隔起来  
                                tempPinyin.append(separator);  
                            }  
                        }  
                    } else {  
                        tempPinyin.append(strs[0]);  
                    }  
      
                } catch (BadHanyuPinyinOutputFormatCombination e) {  
                    e.printStackTrace();  
                }  
            } else {  
                tempPinyin.append(src);  
            }  
      
            return tempPinyin.toString();  
      
        }  
      
          
        public static String hanziToPinyin(String hanzi){  
            return hanziToPinyin(hanzi," ");  
        }  
        /** 
         * 将汉字转换成拼音 
         * @param hanzi 
         * @param separator 
         * @return 
         */  
        public static String hanziToPinyin(String hanzi,String separator){  
                // 创建汉语拼音处理类  
                HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();  
                // 输出设置，大小写，音标方式  
                defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);  
                defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);  
                defaultFormat.setVCharType(HanyuPinyinVCharType.WITH_V);
                  
                String PinyinStr="";  
                try {  
                    PinyinStr=PinyinHelper.toHanyuPinyinString(hanzi, defaultFormat, separator);  
                } catch (BadHanyuPinyinOutputFormatCombination e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }     
                return PinyinStr;  
        }  
        
        /** 
         * 将汉字转换成拼音 （包括所有多音字组合）
         * @param hanzi 
         * @param separator （多音字之间的分隔符）
         * @return 
         */  
        public static String  hanziToPinyinAll(String hanzi,String separator){  
        	String []pingyinArray=null;
        	StringBuilder builder=new StringBuilder();
        	 if(hanzi!=null && !hanzi.trim().equalsIgnoreCase("")){  
        		   char[] srcChar ;  
        		   srcChar=hanzi.toCharArray();  
                // 创建汉语拼音处理类  
                HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();  
                // 输出设置，大小写，音标方式  
                defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);  
                defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);  
                defaultFormat.setVCharType(HanyuPinyinVCharType.WITH_V);
        	 String[][] temp = new String[hanzi.length()][];  
        	   for(int i=0;i<srcChar.length;i++){  
        	    char c = srcChar[i];  
        	    //是中文或者a-z或者A-Z转换拼音(我的需求，是保留中文或者a-z或者A-Z)  
        	    if(String.valueOf(c).matches("[\\u4E00-\\u9FA5]+")){  
        	     try{  
        	      temp[i] = PinyinHelper.toHanyuPinyinStringArray(srcChar[i], defaultFormat);  
        	     }catch(BadHanyuPinyinOutputFormatCombination e) {  
        	      e.printStackTrace();  
        	     }  
        	    }else if((c>=65 && c<=90) || (c>=97 && c<=122)){  
        	     temp[i] = new String[]{String.valueOf(srcChar[i])};  
        	    }else{  
        	     temp[i] = new String[]{""};  
        	    }  
        	   }  
        	   pingyinArray = Exchange(temp); 
        	   //去重转换成字符串
        	   builder.append(stringArrayToString(pingyinArray, separator, true));
        	 }
        	 return builder.toString();
        } 
        /** 
         * 将字符串数组转换成字符串 
         * @param str  
         * @param separator 各个字符串之间的分隔符 
         * @return 
         */  
        public static String stringArrayToString(String[] str, String separator) {  
            return  stringArrayToString(str,separator,false);
        }  
        
        /** 
         * 将字符串数组转换成字符串 
         * @param str  
         * @param separator 各个字符串之间的分隔符 
         * @return 
         */  
        public static String stringArrayToString(String[] str, String separator,boolean remDup) {  
            StringBuffer sb = new StringBuffer();  
            if(remDup){//去掉重复
            	Set<String> set=new HashSet<String>();
            	if(str != null && str.length > 0){
            		 for(String py:str){
            		   if(py != null){
            			   set.add(py);
            		   }               		   
               	   }
            	}         	  
         	   int i=0;
         	   if(set.size() > 0){
         		  for (String setEle : set) {
            		   if(i==0){
            			  sb.append(setEle);
            		   }else{
            			  sb.append(separator).append(setEle);
            		   }
            		   i++;
            	   }
         	   }         	   
            }else{
            	if(str != null && str.length > 0){
            		for (int i = 0; i < str.length; i++) {  
            			if(str[i] != null){
            				sb.append(str[i]);  
        	                if (str.length != (i + 1)) {  
        	                    sb.append(separator);  
        	                }
            			}    	                  
    	            }
            	}	              
            }
            return sb.toString();  
        }  
        
        
        /** 
         * 简单的将各个字符数组之间连接起来 
         * @param str 
         * @return 
         */  
        public  static String stringArrayToString(String[] str){  
            return stringArrayToString(str,"");  
        }  
        /** 
         * 将字符数组转换成字符串 
         * @param str  
         * @param separator 各个字符串之间的分隔符 
         * @return 
         */  
        public static String charArrayToString(char[] ch, String separator) {  
            StringBuffer sb = new StringBuffer();  
            for (int i = 0; i < ch.length; i++) {  
                sb.append(ch[i]);  
                if (ch.length != (i + 1)) {  
                    sb.append(separator);  
                }  
            }  
            return sb.toString();  
        }  
          
        /** 
         * 将字符数组转换成字符串 
         * @param str  
         * @return 
         */  
        public static String charArrayToString(char[] ch) {  
            return charArrayToString(ch," ");  
        }  
      
        /** 
         * 取汉字的首字母 
         * @param src 
         * @param isCapital 是否是大写 
         * @return 
         */  
        public static char[]  getHeadByChar(char src,boolean isCapital){  
            //如果不是汉字直接返回 
            if (src <= 128) {  
                return new char[]{src};  
            }
            
            //如果不是汉字直接返回
//            if(!validateChChar(String.valueOf(src))){
//            	return new char[]{src};
//            }
            //获取所有的拼音  
            String []PinyinStr=PinyinHelper.toHanyuPinyinStringArray(src);
            //如果为空直接返回
            if(PinyinStr == null){
            	return new char[]{src};
            }
            //创建返回对象  
            int polyphoneSize=PinyinStr.length;  
            char [] headChars=new char[polyphoneSize];  
            int i=0;  
            //截取首字符  
            for(String s:PinyinStr){  
                char headChar=s.charAt(0);  
                //首字母是否大写，默认是小写  
                if(isCapital){  
                    headChars[i]=Character.toUpperCase(headChar);  
                 }else{  
                    headChars[i]=headChar;  
                 }  
                i++;  
            }  
              
            return headChars;  
        }  
        
        /** 
         * 取汉字的首字母(默认是大写) 
         * @param src 
         * @return 
         */  
        public static char[]  getHeadByChar(char src){  
            return getHeadByChar(src,true);  
        }  
        /** 
         * 查找字符串首字母 
         * @param src  
         * @return 
         */  
        public  static String[] getHeadByString(String src){  
            return getHeadByString( src, true);  
        }
        
        public  static String[] getHeadByString2(String src){  
            return getHeadByString2( src, true);  
        }
        /** 
         * 查找字符串首字母 
         * @param src  
         * @param isCapital 是否大写 
         * @return 
         */  
        public  static String[] getHeadByString(String src,boolean isCapital){  
            return getHeadByString( src, isCapital,null);  
        } 
        
        public  static String[] getHeadByString2(String src,boolean isCapital){  
            return getHeadByString2( src, isCapital,null);  
        } 
        
        
        /** 
         * 查找字符串首字母 
         * @param src  
         * @param isCapital 是否大写 
         * @param separator 分隔符 
         * @return 
         */  
        public  static String[] getHeadByString(String src,boolean isCapital,String separator){  
            char[]chars=src.toCharArray();  
            String[] headString=new String[chars.length];  
            int i=0;  
            for(char ch:chars){  
                  
                char[]chs=getHeadByChar(ch,isCapital); 
                
                StringBuffer sb=new StringBuffer();  
                if(null!=separator){  
                    int j=1;  
                      
                    for(char ch1:chs){  
                        sb.append(ch1);  
                        if(j!=chs.length){  
                            sb.append(separator);  
                        }  
                        j++;  
                    }  
                }else{  
                    sb.append(chs[0]);  
                }  
                headString[i]=sb.toString();  
                i++;  
            }  
            return headString;  
        }
        
        /** 
         * 查找字符串首字母排除特殊字符和标点符号 
         * @param src  
         * @param isCapital 是否大写 
         * @param separator 分隔符 
         * @return 
         */  
        public  static String[] getHeadByString2(String src,boolean isCapital,String separator){  
            char[]chars=src.toCharArray();  
            String[] headString=new String[chars.length];  
            int i=0;  
            for(char ch:chars){                    
                char[]chs=getHeadByChar(ch,isCapital);
                if(chs.length == 1){
                	if(chs[0] == ch){                		
                		if(!Character.isLetter(chs[0]) && !Character.isDigit(chs[0])){
                			continue;
                		}                		
                	}
                }
                StringBuffer sb=new StringBuffer();  
                if(null!=separator){  
                    int j=1;  
                      
                    for(char ch1:chs){  
                        sb.append(ch1);  
                        if(j!=chs.length){  
                            sb.append(separator);  
                        }  
                        j++;  
                    }  
                }else{  
                    sb.append(chs[0]);  
                }  
                headString[i]=sb.toString();  
           
                i++;  
            }  
            return headString;  
        }
        
        
        /** 
         * 查找字符串首字母 （包括所有多音字组合）
         * @param src  
         * @param isCapital 是否大写 
         * @param separator 分隔符（多音字之前的分隔符） 
         * @return 
         */  
        public  static String getHeadAllByString(String src,boolean isCapital,String separator){  
        	StringBuilder builder=new StringBuilder();
            char[]chars=src.toCharArray();  
            String[][] tempArr=new String[chars.length][];  
            
            for (int k = 0; k < chars.length; k++) {
            	char[]chs=getHeadByChar(chars[k],isCapital);
            	String[] strArr=new String[chs.length];
            	for (int j = 0; j < chs.length; j++) {
                	strArr[j]=String.valueOf(chs[j]);
				}
            	tempArr[k]=strArr;
			}
          String [] headString= Exchange(tempArr); 
          
        builder.append(stringArrayToString(headString, separator, true));
            return builder.toString();  
        }  
        
        
        
        
        
        
        /** 
         * 递归 
         * @author wyh 
         * @param strJaggedArray 
         * @return 
         */  
           public static String[] Exchange(String[][] strJaggedArray){  
               String[][] temp = DoExchange(strJaggedArray);  
               return temp[0];         
           }
        
        
        /** 
         * 递归 
         * @author wyh 
         * @param strJaggedArray 
         * @return 
         */  
        private static String[][] DoExchange(String[][] strJaggedArray){  
            int len = strJaggedArray.length;  
            if(len >= 2){             
                int len1 = strJaggedArray[0].length;  
                int len2 = strJaggedArray[1].length;  
                int newlen = len1*len2;  
                String[] temp = new String[newlen];  
                int Index = 0;  
                for(int i=0;i<len1;i++){  
                    for(int j=0;j<len2;j++){  
                        temp[Index] = strJaggedArray[0][i] + strJaggedArray[1][j];  
                        Index ++;  
                    }  
                }  
                String[][] newArray = new String[len-1][];  
                for(int i=2;i<len;i++){  
                    newArray[i-1] = strJaggedArray[i];                             
                }  
                newArray[0] = temp;  
                return DoExchange(newArray);  
            }else{  
             return strJaggedArray;     
            }  
        }  
        
        
        private static boolean validateChChar(String str){
        	//String reg="[\u3002\uff1b\uff0c\uff1a\u201c\u201d\uff08\uff09\u3001\uff1f\u300a\u300b]";
        	String reg="[\u4e00-\u9fa5]";
        	Pattern pattern = Pattern.compile(reg);
        	Matcher matcher = pattern.matcher(str);
        	return matcher.find();
        }
          
        public static void main(String[] args) {
//        	String hanzi="我的";
//        	String s="";
//        	System.out.println(getHeadAllByString(hanzi, true, "-"));
//        	System.out.println(hanziToPinyinAll(hanzi, ","));
//        	System.out.println(validateChChar("乄"));
        	String[] array = PinyinUtil.getHeadByString2("柯南abc剧场版-黑衣组织满月对决]_柯南-黑衣组织满月对决(1)");
        	System.out.println(array.length);
        	String pinyin = PinyinUtil.stringArrayToString(array);
        	System.out.println(pinyin);
        	//getHeadByString2("柯南剧场版-黑衣组织满月对决]_柯南-黑衣组织满月对决(1)",true,"");
        }
    }  